#pragma once
//自定义协议
#include<iostream>
#include<string>
#include<jsoncpp/json/json.h>

// #define Myself 1

const std::string blank_space_sep = " ";
const std::string protocol_sep = "\n";

//封装有效载荷
//   content = "x op y" ---->  "len"\n"x op y"\n"
std::string Encode(std::string& content)
{
    std::string package = std::to_string(content.size());
    package += protocol_sep;
    package += content;
    package += protocol_sep;
    return package;
}

//分离出有效载荷
// package: "len"\n"x op y"\n"  ---> "x op y"
bool Decode(std::string& package, std::string &content)
{
    size_t pos = package.find(protocol_sep);
    if(pos == std::string::npos) return false;
    std::string str_len = package.substr(0,pos);
    //获取len的大小
    size_t len = std::stoi(str_len);
    //完整报文长度
    size_t total_len = str_len.size() + len + 2;
    if(package.size() < total_len) return false;

    content = package.substr(pos+1, len);

    // 移除报文--后面讲
    package.erase(0, total_len);
    return true;
}


class Request
{
public:
    Request(int data1, int data2, char oper)
        :x(data1)
        ,y(data2)
        ,op(oper)
    {}
    Request()
    {}
public:
    //序列化
    bool Serialize(std::string &out) 
    {
#ifdef Myself
        // 把结构化数据转化为  "x op y"
        //构建报文的有效载荷
        std::string s = std::to_string(x);
        s += blank_space_sep;
        s += op;
        s += blank_space_sep;
        s += std::to_string(y);
        out = s;
        return true;
#else
        Json::Value root;
        root["x"] = x;
        root["y"] = y;
        root["op"] = op;
        Json::FastWriter w;
        out = w.write(root);
        return true;
#endif
    }   
    //反序列化
    bool Desrialize(std::string& in)
    {
#ifdef Myself
        // 把 "x op y" 转化为结构化数据
        size_t left = in.find(blank_space_sep);
        if(left == std::string::npos) return false;
        std::string part_x = in.substr(0, left);

        size_t right = in.rfind(blank_space_sep);
        if(right == std::string::npos) return false;
        std::string part_y = in.substr(right+1);

        if(left + 2 != right) return false;

        x = std::stoi(part_x);
        op = in[left+1];
        y = std::stoi(part_y);
        return true; 
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);

        x = root["x"].asInt();
        y = root["y"].asInt();
        op = root["op"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
       std::cout << "新请求构建完成：" << x << op << y << std::endl;
    }
public:
    int x;
    int y;
    char op;// ->"+-*/"
};

class Response
{

public:
    Response(int res, int c)
        :result(res)
        ,code(c)
    {}
    Response()
    {}
public:
    //序列化
    bool Serialize(std::string &out)
    {
#ifdef Myself
        // 结构化数据转化为 "result code"
        // 构建报文的有效载荷
        std::string s = std::to_string(result);
        s += blank_space_sep;
        s += std::to_string(code);

        out = s;
        return true;
#else
        Json::Value root;
        root["result"] = result;
        root["code"] = code;
        Json::FastWriter w;
        out = w.write(root);
        return true;
#endif
    }

    //反序列化
    bool Desrialize(std::string& in)
    {
#ifdef Myself
        //"result code" 转化为结构化数据
        size_t pos = in.find(blank_space_sep);
        if(pos == std::string::npos) return false;
        std::string part_left = in.substr(0, pos);
        std::string part_right = in.substr(pos+1);

        result = std::stoi(part_left);
        code = std::stoi(part_right);

        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);

        result = root["result"].asInt();
        code = root["code"].asInt();
        return true;
        
#endif
    }
    void DebugPrint()
    {
        std::cout << "结果响应完成, result: " << result << ", code:" << code << std::endl;
    }


public:
    int result;
    int code;//
};